reasoningbank with agentdb

仓库: ruvnet/claude-flow
安装量: 46
排名: #16220

安装

npx skills add https://github.com/proffesor-for-testing/agentic-qe --skill 'ReasoningBank with AgentDB'
ReasoningBank with AgentDB
What This Skill Does
Provides ReasoningBank adaptive learning patterns using AgentDB's high-performance backend (150x-12,500x faster). Enables agents to learn from experiences, judge outcomes, distill memories, and improve decision-making over time with 100% backward compatibility.
Performance
150x faster pattern retrieval, 500x faster batch operations, <1ms memory access. Prerequisites Node.js 18+ AgentDB v1.0.7+ (via agentic-flow) Understanding of reinforcement learning concepts (optional) Quick Start with CLI Initialize ReasoningBank Database

Initialize AgentDB for ReasoningBank

npx agentdb@latest init ./.agentdb/reasoningbank.db --dimension 1536

Start MCP server for Claude Code integration

npx agentdb@latest mcp claude mcp add agentdb npx agentdb@latest mcp Migrate from Legacy ReasoningBank

Automatic migration with validation

npx agentdb@latest migrate --source .swarm/memory.db

Verify migration

npx agentdb@latest stats ./.agentdb/reasoningbank.db
Quick Start with API
import
{
createAgentDBAdapter
,
computeEmbedding
}
from
'agentic-flow/reasoningbank'
;
// Initialize ReasoningBank with AgentDB
const
rb
=
await
createAgentDBAdapter
(
{
dbPath
:
'.agentdb/reasoningbank.db'
,
enableLearning
:
true
,
// Enable learning plugins
enableReasoning
:
true
,
// Enable reasoning agents
cacheSize
:
1000
,
// 1000 pattern cache
}
)
;
// Store successful experience
const
query
=
"How to optimize database queries?"
;
const
embedding
=
await
computeEmbedding
(
query
)
;
await
rb
.
insertPattern
(
{
id
:
''
,
type
:
'experience'
,
domain
:
'database-optimization'
,
pattern_data
:
JSON
.
stringify
(
{
embedding
,
pattern
:
{
query
,
approach
:
'indexing + query optimization'
,
outcome
:
'success'
,
metrics
:
{
latency_reduction
:
0.85
}
}
}
)
,
confidence
:
0.95
,
usage_count
:
1
,
success_count
:
1
,
created_at
:
Date
.
now
(
)
,
last_used
:
Date
.
now
(
)
,
}
)
;
// Retrieve similar experiences with reasoning
const
result
=
await
rb
.
retrieveWithReasoning
(
embedding
,
{
domain
:
'database-optimization'
,
k
:
5
,
useMMR
:
true
,
// Diverse results
synthesizeContext
:
true
,
// Rich context synthesis
}
)
;
console
.
log
(
'Memories:'
,
result
.
memories
)
;
console
.
log
(
'Context:'
,
result
.
context
)
;
console
.
log
(
'Patterns:'
,
result
.
patterns
)
;
Core ReasoningBank Concepts
1. Trajectory Tracking
Track agent execution paths and outcomes:
// Record trajectory (sequence of actions)
const
trajectory
=
{
task
:
'optimize-api-endpoint'
,
steps
:
[
{
action
:
'analyze-bottleneck'
,
result
:
'found N+1 query'
}
,
{
action
:
'add-eager-loading'
,
result
:
'reduced queries'
}
,
{
action
:
'add-caching'
,
result
:
'improved latency'
}
]
,
outcome
:
'success'
,
metrics
:
{
latency_before
:
2500
,
latency_after
:
150
}
}
;
const
embedding
=
await
computeEmbedding
(
JSON
.
stringify
(
trajectory
)
)
;
await
rb
.
insertPattern
(
{
id
:
''
,
type
:
'trajectory'
,
domain
:
'api-optimization'
,
pattern_data
:
JSON
.
stringify
(
{
embedding
,
pattern
:
trajectory
}
)
,
confidence
:
0.9
,
usage_count
:
1
,
success_count
:
1
,
created_at
:
Date
.
now
(
)
,
last_used
:
Date
.
now
(
)
,
}
)
;
2. Verdict Judgment
Judge whether a trajectory was successful:
// Retrieve similar past trajectories
const
similar
=
await
rb
.
retrieveWithReasoning
(
queryEmbedding
,
{
domain
:
'api-optimization'
,
k
:
10
,
}
)
;
// Judge based on similarity to successful patterns
const
verdict
=
similar
.
memories
.
filter
(
m
=>
m
.
pattern
.
outcome
===
'success'
&&
m
.
similarity
>
0.8
)
.
length
>
5
?
'likely_success'
:
'needs_review'
;
console
.
log
(
'Verdict:'
,
verdict
)
;
console
.
log
(
'Confidence:'
,
similar
.
memories
[
0
]
?.
similarity
||
0
)
;
3. Memory Distillation
Consolidate similar experiences into patterns:
// Get all experiences in domain
const
experiences
=
await
rb
.
retrieveWithReasoning
(
embedding
,
{
domain
:
'api-optimization'
,
k
:
100
,
optimizeMemory
:
true
,
// Automatic consolidation
}
)
;
// Distill into high-level pattern
const
distilledPattern
=
{
domain
:
'api-optimization'
,
pattern
:
'For N+1 queries: add eager loading, then cache'
,
success_rate
:
0.92
,
sample_size
:
experiences
.
memories
.
length
,
confidence
:
0.95
}
;
await
rb
.
insertPattern
(
{
id
:
''
,
type
:
'distilled-pattern'
,
domain
:
'api-optimization'
,
pattern_data
:
JSON
.
stringify
(
{
embedding
:
await
computeEmbedding
(
JSON
.
stringify
(
distilledPattern
)
)
,
pattern
:
distilledPattern
}
)
,
confidence
:
0.95
,
usage_count
:
0
,
success_count
:
0
,
created_at
:
Date
.
now
(
)
,
last_used
:
Date
.
now
(
)
,
}
)
;
Integration with Reasoning Agents
AgentDB provides 4 reasoning modules that enhance ReasoningBank:
1. PatternMatcher
Find similar successful patterns:
const
result
=
await
rb
.
retrieveWithReasoning
(
queryEmbedding
,
{
domain
:
'problem-solving'
,
k
:
10
,
useMMR
:
true
,
// Maximal Marginal Relevance for diversity
}
)
;
// PatternMatcher returns diverse, relevant memories
result
.
memories
.
forEach
(
mem
=>
{
console
.
log
(
`
Pattern:
${
mem
.
pattern
.
approach
}
`
)
;
console
.
log
(
`
Similarity:
${
mem
.
similarity
}
`
)
;
console
.
log
(
`
Success Rate:
${
mem
.
success_count
/
mem
.
usage_count
}
`
)
;
}
)
;
2. ContextSynthesizer
Generate rich context from multiple memories:
const
result
=
await
rb
.
retrieveWithReasoning
(
queryEmbedding
,
{
domain
:
'code-optimization'
,
synthesizeContext
:
true
,
// Enable context synthesis
k
:
5
,
}
)
;
// ContextSynthesizer creates coherent narrative
console
.
log
(
'Synthesized Context:'
,
result
.
context
)
;
// "Based on 5 similar optimizations, the most effective approach
// involves profiling, identifying bottlenecks, and applying targeted
// improvements. Success rate: 87%"
3. MemoryOptimizer
Automatically consolidate and prune:
const
result
=
await
rb
.
retrieveWithReasoning
(
queryEmbedding
,
{
domain
:
'testing'
,
optimizeMemory
:
true
,
// Enable automatic optimization
}
)
;
// MemoryOptimizer consolidates similar patterns and prunes low-quality
console
.
log
(
'Optimizations:'
,
result
.
optimizations
)
;
//
4. ExperienceCurator
Filter by quality and relevance:
const
result
=
await
rb
.
retrieveWithReasoning
(
queryEmbedding
,
{
domain
:
'debugging'
,
k
:
20
,
minConfidence
:
0.8
,
// Only high-confidence experiences
}
)
;
// ExperienceCurator returns only quality experiences
result
.
memories
.
forEach
(
mem
=>
{
console
.
log
(
`
Confidence:
${
mem
.
confidence
}
`
)
;
console
.
log
(
`
Success Rate:
${
mem
.
success_count
/
mem
.
usage_count
}
`
)
;
}
)
;
Legacy API Compatibility
AgentDB maintains 100% backward compatibility with legacy ReasoningBank:
import
{
retrieveMemories
,
judgeTrajectory
,
distillMemories
}
from
'agentic-flow/reasoningbank'
;
// Legacy API works unchanged (uses AgentDB backend automatically)
const
memories
=
await
retrieveMemories
(
query
,
{
domain
:
'code-generation'
,
agent
:
'coder'
}
)
;
const
verdict
=
await
judgeTrajectory
(
trajectory
,
query
)
;
const
newMemories
=
await
distillMemories
(
trajectory
,
verdict
,
query
,
{
domain
:
'code-generation'
}
)
;
Performance Characteristics
Pattern Search
150x faster (100µs vs 15ms)
Memory Retrieval
<1ms (with cache)
Batch Insert
500x faster (2ms vs 1s for 100 patterns)
Trajectory Judgment
<5ms (including retrieval + analysis)
Memory Distillation
<50ms (consolidate 100 patterns) Advanced Patterns Hierarchical Memory Organize memories by abstraction level: // Low-level: Specific implementation await rb . insertPattern ( { type : 'concrete' , domain : 'debugging/null-pointer' , pattern_data : JSON . stringify ( { embedding , pattern : { bug : 'NPE in UserService.getUser()' , fix : 'Add null check' } } ) , confidence : 0.9 , // ... } ) ; // Mid-level: Pattern across similar cases await rb . insertPattern ( { type : 'pattern' , domain : 'debugging' , pattern_data : JSON . stringify ( { embedding , pattern : { category : 'null-pointer' , approach : 'defensive-checks' } } ) , confidence : 0.85 , // ... } ) ; // High-level: General principle await rb . insertPattern ( { type : 'principle' , domain : 'software-engineering' , pattern_data : JSON . stringify ( { embedding , pattern : { principle : 'fail-fast with clear errors' } } ) , confidence : 0.95 , // ... } ) ; Multi-Domain Learning Transfer learning across domains: // Learn from backend optimization const backendExperience = await rb . retrieveWithReasoning ( embedding , { domain : 'backend-optimization' , k : 10 , } ) ; // Apply to frontend optimization const transferredKnowledge = backendExperience . memories . map ( mem => ( { ... mem , domain : 'frontend-optimization' , adapted : true , } ) ) ; CLI Operations Database Management

Export trajectories and patterns

npx agentdb@latest export ./.agentdb/reasoningbank.db ./backup.json

Import experiences

npx agentdb@latest import ./experiences.json

Get statistics

npx agentdb@latest stats ./.agentdb/reasoningbank.db

Shows: total patterns, domains, confidence distribution

Migration

Migrate from legacy ReasoningBank

npx agentdb@latest migrate --source .swarm/memory.db --target .agentdb/reasoningbank.db

Validate migration

npx agentdb@latest stats .agentdb/reasoningbank.db Troubleshooting Issue: Migration fails

Check source database exists

ls -la .swarm/memory.db

Run with verbose logging

DEBUG

agentdb:* npx agentdb@latest migrate
--source
.swarm/memory.db
Issue: Low confidence scores
// Enable context synthesis for better quality
const
result
=
await
rb
.
retrieveWithReasoning
(
embedding
,
{
synthesizeContext
:
true
,
useMMR
:
true
,
k
:
10
,
}
)
;
Issue: Memory growing too large
// Enable automatic optimization
const
result
=
await
rb
.
retrieveWithReasoning
(
embedding
,
{
optimizeMemory
:
true
,
// Consolidates similar patterns
}
)
;
// Or manually optimize
await
rb
.
optimize
(
)
;
Learn More
AgentDB Integration
node_modules/agentic-flow/docs/AGENTDB_INTEGRATION.md
GitHub
:
https://github.com/ruvnet/agentic-flow/tree/main/packages/agentdb
MCP Integration
:
npx agentdb@latest mcp
Website
:
https://agentdb.ruv.io
Category
Machine Learning / Reinforcement Learning
Difficulty
Intermediate
Estimated Time
20-30 minutes
← 返回排行榜